home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / CollView.C < prev    next >
C/C++ Source or Header  |  1990-12-04  |  10KB  |  481 lines
  1. //$CellSelector,CollectionView$
  2. #include "CollView.h"
  3. #include "Menu.h"
  4. #include "String.h"
  5. #include "Collection.h"
  6. #include "VObject.h"
  7. #include "CmdNo.h"
  8. #include "Error.h"
  9. #include "Math.h"
  10.  
  11. //---- CollectionView ----------------------------------------------------------
  12.  
  13. MetaImpl(CollectionView, (TP(coll), T(selection), T(gap), T(minExtent),
  14.                 T(rows), T(cols), TP(defaultItem), TP(menu), 0));
  15.  
  16. CollectionView::CollectionView(EvtHandler *eh, Collection *m, CollViewOptions o,
  17.                         int r, int c) : View(eh, gRect0)
  18. {
  19.     SetFlag(o);
  20.     defaultItem= new VObject();
  21.     rows= r;
  22.     cols= c;
  23.     SetCollection(m);
  24. }
  25.  
  26. CollectionView::~CollectionView()
  27. {
  28.     if (coll) {
  29.     coll->RemoveObserver(this);
  30.     coll->FreeAll();
  31.     SafeDelete(coll);
  32.     }
  33.     SafeDelete(xPos);
  34.     SafeDelete(yPos);
  35.     SafeDelete(defaultItem);
  36. }
  37.  
  38. //---- init methods
  39.  
  40. int CollectionView::SetSelection(Rectangle newsel)
  41. {
  42.     if (selection != newsel) {
  43.     if (IsOpen()) {
  44.         InvalidateRect(ItemRect(selection));
  45.         InvalidateRect(ItemRect(newsel));
  46.     }
  47.     selection= newsel;
  48.     if (selection.IsEmpty())
  49.         return 0;   // no selection
  50.     return 1;       // selection changed
  51.     }
  52.     return 2;           // no change
  53. }
  54.  
  55. void CollectionView::SetCollection(class Collection* m, bool freeold)
  56. {
  57.     if (coll)
  58.     coll->RemoveObserver(this);
  59.     if (freeold && coll) {
  60.     coll->FreeAll();
  61.     delete coll;
  62.     }
  63.     if (coll= m) {
  64.     coll->AssertClass(VObject);
  65.     coll->AddObserver(this);
  66.     }
  67.     selection= gRect0;
  68.     Modified();
  69.     Scroll(cPartScrollAbs, gPoint0, FALSE);
  70. }
  71.  
  72. void CollectionView::SetDefaultItem(class VObject *d)
  73. { 
  74.     if (defaultItem)
  75.     delete defaultItem;
  76.     defaultItem= d; 
  77. }
  78.  
  79. void CollectionView::SetMinExtent(Point e)
  80. {
  81.     if (minExtent != e) {
  82.     minExtent= e;
  83.     Modified();
  84.     }
  85. }
  86.  
  87. Metric CollectionView::GetMinSize()
  88. {
  89.     Update();
  90.     return GetExtent();
  91. }
  92.  
  93. //---- layout
  94.  
  95. void CollectionView::ConstrainScroll(Point *p)
  96. {
  97.     bool outside;
  98.     Point pp= PointToItem(*p, &outside);
  99.     if (! outside)
  100.     p->y= ItemRect(0, pp.y).origin.y;
  101. }
  102.  
  103. void CollectionView::SetOrigin(Point at)
  104. {
  105.     register int x, y;
  106.     
  107.     View::SetOrigin(at);
  108.     at+= gap;
  109.     for (x= 0; x < cols; x++)
  110.     for (y= 0; y < rows; y++)
  111.         GetItem(x, y)->SetOrigin(Point(xPos[x]+at.x, yPos[y]+at.y));
  112. }
  113.  
  114. void CollectionView::Update()
  115. {
  116.     register VObject *gop;
  117.     register int x, y, ww, hh, w, h;
  118.     int xpos= 0, ypos= 0, sz;
  119.     Rectangle r;
  120.     Point g;
  121.  
  122.     if (!TestFlag(eCVModified))
  123.     return;
  124.     ResetFlag(eCVModified);
  125.     if (coll == 0) {
  126.     ForceRedraw();
  127.     return;
  128.     }
  129.     sz= coll->Size();
  130.     if (rows <= 0)
  131.     SetFlag(eCVExpandRows);
  132.     if (cols <= 0)
  133.     SetFlag(eCVExpandCols);
  134.     
  135.     if (TestFlag(eCVExpandRows) && TestFlag(eCVExpandCols)) {
  136.     cols= intsqrt(sz);
  137.     rows= (sz+cols-1) / cols;
  138.     } else if (TestFlag(eCVExpandRows))
  139.     rows= (sz+cols-1) / cols;
  140.     else if (TestFlag(eCVExpandCols))
  141.     cols= (sz+rows-1) / rows;
  142.  
  143.     yPos= (short*) Realloc(yPos, (rows+1) * sizeof(short));
  144.     xPos= (short*) Realloc(xPos, (cols+1) * sizeof(short));
  145.  
  146.     xpos= ypos= 0;
  147.     g= 2*gap;
  148.     if (TestFlag(eCVGrid))
  149.     g+= gPoint1;
  150.     
  151.     for (x= 0; x < cols; x++) {
  152.     xPos[x]= xpos;
  153.     ww= minExtent.x;
  154.     for (y= 0; y < rows; y++) {
  155.         gop= GetItem(x, y);
  156.         gop->SetContainer(this);
  157.         gop->CalcExtent();
  158.         w= gop->Width();
  159.         ww= max(ww, w);
  160.     }
  161.     xpos+= ww+g.x;
  162.     }
  163.     xPos[x]= xpos;
  164.  
  165.     for (y= 0; y < rows; y++) {
  166.     yPos[y]= ypos;
  167.     hh= minExtent.y;
  168.     for (x= 0; x < cols; x++) {
  169.         h= GetItem(x, y)->Height();
  170.         hh= max(hh, h);
  171.     }
  172.     ypos+= hh+g.y;
  173.     }
  174.     yPos[y]= ypos;
  175.  
  176.     for (x= 0; x < cols; x++)
  177.     for (y= 0; y < rows; y++)
  178.         GetItem(x, y)->SetContentRect(ItemRect(x, y).Inset(gap), FALSE);
  179.  
  180.     if (TestFlag(eCVGrid)) {
  181.     xpos--;
  182.     ypos--;
  183.     }
  184.     SetExtent(Point(xpos, ypos));
  185.     ForceRedraw();
  186. }
  187.  
  188. //---- update
  189.  
  190. void CollectionView::DoObserve(int, int, void *, Object *op)
  191. {
  192.     if (op == coll)
  193.     Modified();
  194. }
  195.  
  196. void CollectionView::Modified()
  197. {
  198.     SetFlag(eCVModified);
  199.     if (IsOpen())
  200.     Update();
  201. }
  202.  
  203. //---- mapping
  204.  
  205. Point CollectionView::PointToItem(Point p, bool *outside)
  206. {
  207.     register int x, y;
  208.     register bool out= FALSE;
  209.  
  210.     if (coll == 0 || coll->Size() <= 0) {
  211.     if (outside)
  212.         *outside= TRUE;
  213.     return gPoint0;
  214.     }
  215.     p-= GetOrigin();
  216.     if (p.x < xPos[0]) {
  217.     out= TRUE;
  218.     x= 0;
  219.     } else if (p.x >= xPos[cols]) {
  220.     out= TRUE;
  221.     x= cols-1;
  222.     } else {
  223.     for (x= 0; x < cols; x++)
  224.         if (p.x >= xPos[x] && p.x < xPos[x+1])
  225.         break;
  226.     }
  227.     if (p.y < yPos[0]) {
  228.     out= TRUE;
  229.     y= 0;
  230.     } else if (p.y >= yPos[rows]) {
  231.     out= TRUE;
  232.     y= rows-1;
  233.     } else {
  234.     for (y= 0; y < rows; y++)
  235.         if (p.y >= yPos[y] && p.y < yPos[y+1])
  236.         break;
  237.     }
  238.     if (outside)
  239.     *outside= out;
  240.     return Point(x, y);
  241. }
  242.  
  243. Rectangle CollectionView::ItemRect(Rectangle r)
  244. {
  245.     Rectangle rr;
  246.  
  247.     if (r.IsEmpty())
  248.     return gRect0;
  249.     Update();
  250.     rr.origin.x= xPos[r.origin.x];
  251.     rr.origin.y= yPos[r.origin.y];
  252.     rr.extent.x= xPos[r.origin.x+r.extent.x] - rr.origin.x;
  253.     rr.extent.y= yPos[r.origin.y+r.extent.y] - rr.origin.y;
  254.     if (TestFlag(eCVGrid))
  255.     rr.extent-= gPoint1;
  256.     return rr+GetOrigin();
  257. }
  258.  
  259. Point CollectionView::ItemPos(VObjPtr g)
  260. {
  261.     VObjPtr gop;
  262.     Iter next(coll);
  263.  
  264.     Update();
  265.     for (int i= 0; gop= (VObject*) next(); i++)
  266.     if (gop == g)
  267.         break;
  268.     if (i >= coll->Size())
  269.     return gPoint_1;
  270.     return Point(i/rows, i%rows);
  271. }
  272.  
  273. Rectangle CollectionView::ItemRect(int x, int y)
  274. {
  275.     x= range(0, cols, x);
  276.     y= range(0, rows, y);
  277.     Rectangle r(xPos[x], yPos[y], xPos[x+1]-xPos[x], yPos[y+1]-yPos[y]);
  278.     if (TestFlag(eCVGrid))
  279.     r.extent-= gPoint1;
  280.     r.origin+= GetOrigin();
  281.     return r;
  282. }
  283.  
  284. VObject *CollectionView::GetItem(int x, int y)
  285. {
  286.     VObject *gop= 0;
  287.     int ix= x*rows+y;
  288.     
  289.     if (ix >= 0 && ix < coll->Size())
  290.     gop= (VObject*)coll->At(x*rows+y);
  291.     return gop ? gop : defaultItem;
  292. }
  293.  
  294. //---- menus
  295.  
  296. Menu *CollectionView::GetMenu()
  297. {
  298.     if (menu)
  299.     return menu;
  300.     return View::GetMenu();
  301. }
  302.  
  303. void CollectionView::DoCreateMenu(Menu *m)
  304. {
  305.     if (menu == 0)
  306.     View::DoCreateMenu(m);
  307. }
  308.  
  309. //---- event handlung
  310.  
  311. Command *CollectionView::DoLeftButtonDownCommand(Point lp, Token t, int clicks)
  312. {
  313.     if (coll && coll->Size() > 0)
  314.     return new CellSelector(this, clicks);
  315.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  316. }
  317.  
  318. Command *CollectionView::DoKeyCommand(int ch, Point, Token)
  319. {
  320.     register VObject *gop= 0;
  321.     register int i;
  322.     int start= 0;
  323.     Rectangle r= GetViewedRect();
  324.     
  325.     if (r.IsNotEmpty()) {
  326.     start= r.origin.y+r.extent.y;
  327.     if (start <= GetExtent().y)
  328.         start= PointToItem(Point(0,start)).y;
  329.     }
  330.  
  331.     for (i= 0; i < rows; i++) {
  332.     gop= GetItem(0, (start+i) % rows);
  333.     if (gop && (sortmap[gop->AsString()[0]] == sortmap[ch]))
  334.         break;
  335.     }
  336.  
  337.     if (gop)
  338.     RevealAlign(ItemRect(Rectangle(ItemPos(gop), gPoint1)));
  339.     return gNoChanges;
  340. }
  341.  
  342. void CollectionView::DoOnItem(int m, VObject *vp, Point p)
  343. {
  344.     if (vp)
  345.     vp->DoOnItem(m, 0, p);
  346. }
  347.  
  348. void CollectionView::DoSelect2(Rectangle, int clickCount)
  349. {
  350.     if (GetSelection().IsNotEmpty())
  351.     DoSelect(GetSelection(), clickCount);
  352. }
  353.  
  354. void CollectionView::DoSelect(Rectangle r, int clicks)
  355. {
  356.     if (r.IsNotEmpty()) {
  357.     int partcode= clicks >= 2 ? cPartCollDoubleSelect: cPartCollSelect;
  358.     Control(GetId(), partcode, (void*) r.origin.y);
  359.     if (TestFlag(eCVClearSelection))
  360.         SetNoSelection();
  361.     }
  362. }
  363.  
  364. //---- drawing
  365.  
  366. void CollectionView::Draw(Rectangle r)
  367. {
  368.     register int x, y;
  369.     register VObject *gop;
  370.     Point p1, p2;
  371.  
  372.     if (coll == 0 || coll->Size() <= 0)
  373.     return;
  374.     p1= PointToItem(r.NW());
  375.     p2= PointToItem(r.SE()+gPoint1);
  376.     int i= 0;
  377.     for (x= p1.x; x <= p2.x; x++) {
  378.     for (y= p1.y; y <= p2.y; y++) {
  379.         i++;
  380.         gop= GetItem(x, y);
  381.         gop->DrawAll(gop->contentRect,
  382.             selection.ContainsPoint(Point(x, y)) && gop->Enabled());
  383.     }
  384.     }
  385.     if (TestFlag(eCVGrid)) {
  386.     GrSetPenNormal();
  387.     DrawGrid(p1, p2);
  388.     }
  389. }
  390.  
  391. void CollectionView::DrawGrid(Point p1, Point p2)
  392. {
  393.     register int x, y;
  394.     int xx= 0, yy= 0;
  395.     Point o= GetOrigin();
  396.  
  397.     if (p2.x >= cols-1)
  398.     xx= 1;
  399.     if (p2.y >= rows-1)
  400.     yy= 1;
  401.     for (x= p1.x; x <= p2.x-xx; x++)
  402.     GrLine(Point(xPos[x+1]-1, yPos[p1.y])+o, Point(xPos[x+1]-1, yPos[p2.y+1]-1)+o);
  403.     for (y= p1.y; y <= p2.y-yy; y++)
  404.     GrLine(Point(xPos[p1.x], yPos[y+1]-1)+o, Point(xPos[p2.x+1]-1, yPos[y+1]-1)+o);
  405. }
  406.  
  407. //---- input/output
  408.  
  409. ostream& CollectionView::PrintOn(ostream &s)
  410. {
  411.     Object::PrintOn(s);
  412.     return s << gap SP << minExtent SP << rows SP << cols SP << defaultItem SP << coll SP;
  413. }
  414.  
  415. bool CollectionView::PrintOnWhenObserved(Object *from)
  416. {
  417.     return from != coll;
  418. }
  419.  
  420. istream& CollectionView::ReadFrom(istream &s)
  421. {
  422.     Collection *m;
  423.     VObject *di;
  424.  
  425.     Object::ReadFrom(s);
  426.     s >> gap >> minExtent >> rows >> cols >> di >> m;
  427.     SetCollection(m);
  428.     SetDefaultItem(di);
  429.     return s;
  430. }
  431.  
  432. void CollectionView::Parts(Collection* col)
  433. {
  434.     View::Parts(col);
  435.     if (coll && coll->Size() < 12) // hack
  436.     col->Add(coll);
  437. }
  438.  
  439. //---- CellSelector ------------------------------------------------------------
  440.  
  441. CellSelector::CellSelector(CollectionView* v, int clicks)
  442. { 
  443.     SetFlag(eCmdNoReplFeedback);
  444.     lvp= v;
  445.     clickCount= clicks;
  446. }
  447.  
  448. void CellSelector::TrackFeedback(Point, Point pp, bool on)
  449. {
  450.     if (on) {
  451.     int code;
  452.     if (itemptr && itemptr->Enabled())
  453.         code= lvp->SetSelection(Rectangle(item, gPoint1));
  454.     else
  455.         code= lvp->SetSelection(gRect0);
  456.     lvp->DoOnItem(code, itemptr, pp);
  457.     }
  458. }
  459.  
  460. Command *CellSelector::TrackMouse(TrackPhase atp, Point, Point, Point np)
  461. {
  462.     bool outside= FALSE;
  463.     
  464.     item= lvp->PointToItem(np, &outside);
  465.     if (outside && lvp->TestFlag(eCVDontStuckToBorder))
  466.     itemptr= 0;
  467.     else
  468.     itemptr= lvp->GetItem(item.x, item.y);
  469.     
  470.     switch (atp) {
  471.     case eTrackRelease:
  472.     lvp->DoSelect2(lvp->GetSelection(), clickCount);
  473.     case eTrackExit:
  474.     return gNoChanges;
  475.     default:
  476.     break;
  477.     }
  478.     return this;
  479. }
  480.  
  481.